home *** CD-ROM | disk | FTP | other *** search
/ Games of Daze / Infomagic - Games of Daze (Summer 1995) (Disc 1 of 2).iso / djgpp / go32 / dalloc.c < prev    next >
C/C++ Source or Header  |  1994-07-18  |  4KB  |  184 lines
  1. /* This is file DALLOC.C */
  2. /*
  3. ** Copyright (C) 1993 DJ Delorie, 24 Kirsten Ave, Rochester NH 03867-2954
  4. **
  5. ** This file is distributed under the terms listed in the document
  6. ** "copying.dj", available from DJ Delorie at the address above.
  7. ** A copy of "copying.dj" should accompany this file; if not, a copy
  8. ** should be available from where this file was obtained.  This file
  9. ** may not be distributed without a verbatim copy of "copying.dj".
  10. **
  11. ** This file is distributed WITHOUT ANY WARRANTY; without even the implied
  12. ** warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
  13. */
  14.  
  15. /* History:22,22 */
  16.  
  17. #include <stdio.h>
  18. #include <stdlib.h>
  19. #include <dos.h>
  20. #include <dir.h>
  21. #include <io.h>
  22. #include <fcntl.h>
  23. #include <sys/stat.h>
  24. #include <string.h>
  25.  
  26. #include "gotypes.h"
  27. #include "valloc.h"
  28. #include "dalloc.h"
  29. #include "mono.h"
  30. #include "control.h"
  31.  
  32. #define DA_FREE    0
  33. #define DA_USED    1
  34.  
  35. #define MAX_DBLOCK 32760 /* 4095 * 8 -> 128 Mb */
  36.  
  37. static int dalloc_initted = 0;
  38. static word8 map[4096];
  39. static first_avail;
  40. static int dfile = -1;
  41. static word32 disk_used = 0;
  42.  
  43. extern int debug_mode;
  44. extern transfer_buffer[];
  45.  
  46. static void dset(unsigned i, int b)
  47. {
  48.   unsigned o, m;
  49.   o = i>>3;
  50.   m = 1<<(i&7);
  51.   if (b)
  52.     map[o] |= m;
  53.   else
  54.     map[o] &= ~m;
  55. }
  56.  
  57. static int dtest(unsigned i)
  58. {
  59.   unsigned o, m;
  60.   o = i>>3;
  61.   m = 1<<(i&7);
  62.   return map[o] & m;
  63. }
  64.  
  65. static char dfilename[80];
  66.  
  67. void dalloc_init(void)
  68. {
  69.   int i;
  70.   char *tmp;
  71.   tmp = getenv("GO32TMP");
  72.   if (!tmp) tmp = getenv("GCCTMP");
  73.   if (!tmp) tmp = getenv("TMP");
  74.   if (!tmp) tmp = getenv("TEMP");
  75.   if (!tmp) tmp = "/";
  76.   if ((tmp[strlen(tmp)-1] == '/') || (tmp[strlen(tmp)-1] == '\\'))
  77.     sprintf(dfilename, "%spg%04xXXXXXX", tmp, _CS);
  78.   else
  79.     sprintf(dfilename, "%s/pg%04xXXXXXX", tmp, _CS);
  80.   for (i=0; i<4096; i++)
  81.     map[i] = 0;
  82.   dset(0, DA_USED);
  83.   
  84.   dalloc_initted = 1;
  85.   if (show_memory_info)
  86.   {
  87.     fprintf(stderr, "Swap space available: %ld Kb\n", dalloc_max_size() * 4L);
  88.   }
  89. }
  90.  
  91. void dalloc_uninit(void)
  92. {
  93.   if (dfile == -1)
  94.     return;
  95.   close(dfile);
  96.   unlink(dfilename);
  97. }
  98.  
  99. unsigned dalloc(void)
  100. {
  101.   char buf[8];
  102.   int i;
  103.   unsigned pn;
  104.   if (!dalloc_initted)
  105.     dalloc_init();
  106.   for (pn=first_avail; pn<=MAX_DBLOCK; pn++)
  107.     if (dtest(pn) == DA_FREE)
  108.     {
  109.       dset(pn, DA_USED);
  110.       first_avail = pn+1;
  111.       disk_used++;
  112.       if (topline_info)
  113.       {
  114.         sprintf(buf, "%6ldk", disk_used*4);
  115.         for (i=0; i<7; i++)
  116.           poke(screen_seg, (54+i)*2, buf[i]|0x0c00);
  117.       }
  118.       return pn;
  119.     }
  120.   fprintf(stderr, "Fatal: out of swap space!\n");
  121.   return 0;
  122. }
  123.  
  124. void dfree(unsigned pn)
  125. {
  126.   dset(pn, DA_FREE);
  127.   if (pn < first_avail)
  128.     first_avail = pn;
  129.   disk_used--;
  130. }
  131.  
  132. unsigned dalloc_max_size(void)
  133. {
  134.   word32 fr;
  135.   struct REGPACK r;
  136.   r.r_ax = 0x3600;
  137.   if (dfilename[1] == ':')
  138.     r.r_dx = dfilename[0] & 0x1f;
  139.   else
  140.     r.r_dx = 0;
  141.   intr(0x21, &r);
  142.   if (r.r_ax == 0xffff)
  143.     return 0;
  144.   fr = (word32)r.r_ax * (word32)r.r_bx * (word32)r.r_cx;
  145.   fr /= 4096L;
  146.   fr += (unsigned long)disk_used;
  147.   if (fr > MAX_DBLOCK)
  148.     fr = MAX_DBLOCK;
  149.   return (unsigned)fr;
  150. }
  151.  
  152. unsigned dalloc_used(void)
  153. {
  154.   return (unsigned)disk_used;
  155. }
  156.  
  157. void dwrite(word8 *buf, unsigned block)
  158. {
  159.   int c;
  160.   if(dfile < 0) {
  161.     mktemp(dfilename);
  162.     dfile = open(dfilename, O_RDWR|O_BINARY|O_CREAT|O_TRUNC, S_IWRITE|S_IREAD);
  163.     if (dfile < 0)
  164.     {
  165. fprintf(stderr, "Fatal! cannot open swap file %s\n", dfilename);
  166. exit(1);
  167.     }
  168.     write(dfile, "go32 paging file\r\n\r\n\x1a", 22);
  169.   }
  170.   lseek(dfile, (long)block*4096L, 0);
  171.   c = write(dfile, buf, 4096);
  172.   if (c < 4096)
  173.   {
  174.     fprintf(stderr, "Fatal! disk full writing to swap file\n");
  175.     exit(1);
  176.   }
  177. }
  178.  
  179. void dread(word8 *buf, unsigned block)
  180. {
  181.   lseek(dfile, (long)block*4096L, 0);
  182.   read(dfile, buf, 4096);
  183. }
  184.